package com.vdong.redis.data.core.json.ops.impl;

import com.vdong.redis.data.core.json.FastJsonRedisTemplate;
import com.vdong.redis.data.core.json.ops.FastJsonBoundZSetOperations;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.connection.RedisZSetCommands.Limit;
import org.springframework.data.redis.connection.RedisZSetCommands.Range;
import org.springframework.data.redis.core.BoundZSetOperations;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.ZSetOperations.TypedTuple;

import java.util.Collection;
import java.util.Date;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/** ops覆盖类，可提供原先ops没有的方法
* @author <a href="mailto:zhudelie@zuozh.com">zhudelie</a>
* @version
* @since JDK 1.6
* create on 2017年3月31日
* Copyright 2017 ZZJR All Rights Reserved.
*
*/
public class FastJsonBoundZSetOperationsImpl<K,V> extends OperationsAware<K, V> implements FastJsonBoundZSetOperations<K,V> {
   private BoundZSetOperations<K,V> ops;
   public FastJsonBoundZSetOperationsImpl(BoundZSetOperations<K,V> ops, FastJsonRedisTemplate<K,V> template){
       super(template);
       this.ops = ops;
   }

   public BoundZSetOperations<K,V> getOps(){
       return ops;
   }
   /**
    * 获得key
    */

   public K getKey() {
       // TODO Auto-generated method stub
       return  (K) getOps().getKey();
   }
   /**
    * 获得类型
    */

   public DataType getType() {
       // TODO Auto-generated method stub
       return getOps().getType();
   }


   public Long getExpire() {
       // TODO Auto-generated method stub
       return getOps().getExpire();
   }
   /**
    * 设置过期时间
    */

   public Boolean expire(long timeout, TimeUnit unit) {
       // TODO Auto-generated method stub
       return getOps().expire(timeout, unit);
   }
   /**
    * 设置过期时间
    */

   public Boolean expireAt(Date date) {
       // TODO Auto-generated method stub
       return getOps().expireAt(date);
   }
   /**
    * 取消过期时间
    */

   public Boolean persist() {
       // TODO Auto-generated method stub
       return getOps().persist();
   }
   /**
    * 重命名
    */

   public void rename(K newKey) {
       getOps().rename(newKey);
   }


   /**
    * 添加值
    */

   public Boolean add(V value, double score) {
       // TODO Auto-generated method stub
       return getOps().add(value, score);
   }
   /**
    * 添加多个值
    */

   public Long add(Set<TypedTuple<V>> tuples) {
       // TODO Auto-generated method stub
       return getOps().add(tuples);
   }
   /**
    * 删除多个值
    */

   public Long remove(Object... values) {
       // TODO Auto-generated method stub
       return getOps().remove(values);
   }
   /**
    * 添加单位成员的有序集合存储增量键比分
    */

   public Double incrementScore(V value, double delta) {
       // TODO Auto-generated method stub
       return getOps().incrementScore(value, delta);
   }
   /**
    * 返回成员的有序集合保存在key，由低到高的分数顺序排名
    */

   public Long rank(Object o) {
       // TODO Auto-generated method stub
       return getOps().rank(o);
   }
   /**
    * 返回有序集中成员的排名。其中有序集成员按分数值递减(从大到小)排序
    */

   public Long reverseRank(Object o) {
       // TODO Auto-generated method stub
       return getOps().reverseRank(o);
   }
   /**
    * 取有序集中第start位到end位的元素
    */

   public Set<V> range(long start, long end) {
       // TODO Auto-generated method stub
       return getOps().range(start, end);
   }
   /**
    * 取有序集中第start位到end位的元素，返回TypedTuple，包含score
    */

   public Set<TypedTuple<V>> rangeWithScores(long start, long end) {
       // TODO Auto-generated method stub
       return getOps().rangeWithScores(start, end);
   }
   /**
    * 取有序集中分数为min到max的元素
    */

   public Set<V> rangeByScore(double min, double max) {
       // TODO Auto-generated method stub
       return getOps().rangeByScore(min, max);
   }
   /**
    * 取有序集中分数为min到max的元素，返回TypedTuple，包含score
    */

   public Set<TypedTuple<V>> rangeByScoreWithScores(double min, double max) {
       // TODO Auto-generated method stub
       return getOps().rangeByScoreWithScores(min, max);
   }
   /**
    * 对start到end的元素进行倒序
    */

   public Set<V> reverseRange(long start, long end) {
       // TODO Auto-generated method stub
       return getOps().reverseRange(start, end);
   }
   /**
    * 对start到end的元素进行倒序，并返回TypedTuple，包含score
    */

   public Set<TypedTuple<V>> reverseRangeWithScores(long start, long end) {
       // TODO Auto-generated method stub
       return getOps().reverseRangeWithScores(start, end);
   }
   /**
    * 对分数为min到max的元素进行倒序
    */

   public Set<V> reverseRangeByScore(double min, double max) {
       // TODO Auto-generated method stub
       return getOps().reverseRangeByScore(min,max);
   }
   /**
    * 对分数为min到max的元素进行倒序，并返回TypedTuple，包含score
    */

   public Set<TypedTuple<V>> reverseRangeByScoreWithScores(double min, double max) {
       // TODO Auto-generated method stub
       return getOps().reverseRangeByScoreWithScores(min, max);
   }
   /**
    * 统计分数值在min到max范围内的元素个数
    */

   public Long count(double min, double max) {
       // TODO Auto-generated method stub
       return getOps().count(min, max);
   }
   /**
    * 元素个数
    */

   public Long size() {
       // TODO Auto-generated method stub
       return getOps().size();
   }


   public Long zCard() {
       // TODO Auto-generated method stub
       return getOps().zCard();
   }
   /**
    * 指定元素的分数
    */

   public Double score(Object o) {
       // TODO Auto-generated method stub
       return getOps().score(o);
   }
   /**
    *删除下标start到end的元素
    */

   public void removeRange(long start, long end) {
       getOps().removeRange(start, end);
   }
   /**
    *删除分数min到max的元素
    */

   public void removeRangeByScore(double min, double max) {
       getOps().removeRangeByScore(min, max);
   }
   /**
    * 并集，如果destkey存在，则覆盖
    */

   public void unionAndStore(K otherKey, K destKey) {
       getOps().unionAndStore(otherKey, destKey);
   }
   /**
    * 并集，如果destkey存在，则覆盖
    */

   public void unionAndStore(Collection<K> otherKeys, K destKey) {
       getOps().unionAndStore(otherKeys, destKey);
   }
   /**
    *  交集，如果destkey存在，则覆盖
    */

   public void intersectAndStore(K otherKey, K destKey) {
       getOps().intersectAndStore(otherKey, destKey);
   }
   /**
    *  交集，如果destkey存在，则覆盖
    */

   public void intersectAndStore(Collection<K> otherKeys, K destKey) {
       getOps().intersectAndStore(otherKeys, destKey);
   }


   public Cursor<TypedTuple<V>> scan(ScanOptions options) {
       // TODO Auto-generated method stub
       return getOps().scan(options);
   }
   /**
    * 返回存储在键的排序集合在指定的范围元素。该元素被认为是从最低到最高的分值进行排序。字典顺序用于以相等的分数的元素。两个开始和结束是从零开始的索引，其中0是第一个元素，1是下一个元素等等。它们也可以是表示偏移量从有序集的结尾，以-1作为排序的集合的最后一个元素，-2倒数第二元素等负数
    */

   public Set<V> rangeByLex(Range range) {
       // TODO Auto-generated method stub
       return getOps().rangeByLex(range);
   }
   /**
    * 返回存储在键的排序集合在指定的范围元素。该元素被认为是从最低到最高的分值进行排序。字典顺序用于以相等的分数的元素。两个开始和结束是从零开始的索引，其中0是第一个元素，1是下一个元素等等。它们也可以是表示偏移量从有序集的结尾，以-1作为排序的集合的最后一个元素，-2倒数第二元素等负数
    */

   public Set<V> rangeByLex(Range range, Limit limit) {
       // TODO Auto-generated method stub
       return getOps().rangeByLex(range, limit);
   }


}
